def get_value(self, dictionary):
        if html.is_html_input(dictionary):
            return html.parse_html_list(dictionary, prefix=self.field_name, default=empty)
        return dictionary.get(self.field_name, empty)

    def run_validation(self, data=empty):
        is_empty_value, data = self.validate_empty_values(data)
        if is_empty_value:
            return data

        value = self.to_internal_value(data)
        try:
            self.run_validators(value)
            value = self.validate(value)
            assert value is not None, '.validate() should return the validated data'
        except (ValidationError, DjangoValidationError) as exc:
            raise ValidationError(detail=as_serializer_error(exc))

        return value

    def run_child_validation(self, data):
        child = copy.deepcopy(self.child)
        if getattr(self, 'partial', False) or getattr(self.root, 'partial', False):
            child.partial = True

        # Field.__deepcopy__ re-instantiates the field, wiping any state.
        # If the subclass set an instance or initial_data on self.child,
        # we manually restore them to the deepcopied child.
        child_instance = getattr(self.child, 'instance', None)
        if child_instance is not None and child_instance is not self.instance:
            child.instance = child_instance
        elif hasattr(self, '_instance_map') and isinstance(data, dict):
            # Automated instance matching (#8926)
            data_pk = data.get('id') or data.get('pk')
            if data_pk is not None:
                child.instance = self._instance_map.get(str(data_pk))
            else:
                child.instance = None
        else:
            child.instance = None

        child_initial_data = getattr(self.child, 'initial_data', empty)
        if child_initial_data is not empty:
            child.initial_data = child_initial_data
        else:
            # Set initial_data for item-level validation if not already set.
            child.initial_data = data

        validated = child.run_validation(data)
        return validated

    def to_internal_value(self, data):
        if html.is_html_input(data):
            data = html.parse_html_list(data, default=[])

        if not isinstance(data, list):
            raise ValidationError({
                api_settings.NON_FIELD_ERRORS_KEY: [
                    self.error_messages['not_a_list'].format(input_type=type(data).__name__)
                ]
            })

        if not self.allow_empty and len(data) == 0:
            raise ValidationError({
                api_settings.NON_FIELD_ERRORS_KEY: [ErrorDetail(self.error_messages['empty'], code='empty')]
            })

        if self.max_length is not None and len(data) > self.max_length:
            raise ValidationError({
                api_settings.NON_FIELD_ERRORS_KEY: [ErrorDetail(self.error_messages['max_length'].format(max_length=self.max_length), code='max_length')]
            })

        if self.min_length is not None and len(data) < self.min_length:
            raise ValidationError({
                api_settings.NON_FIELD_ERRORS_KEY: [ErrorDetail(self.error_messages['min_length'].format(min_length=self.min_length), code='min_length')]
            })

        # Build a primary key mapping for instance updates (#8926)
        instance_map = {}
        if self.instance is not None:
            if isinstance(self.instance, Mapping):
                instance_map = {str(k): v for k, v in self.instance.items()}
            elif hasattr(self.instance, '__iter__'):
                for obj in self.instance:
                    pk = getattr(obj, 'pk', getattr(obj, 'id', None))
                    if pk is not None:
                        instance_map[str(pk)] = obj

        self._instance_map = instance_map

        try:
            ret = []
            errors = []

            for item in data:
                try:
                    validated = self.run_child_validation(item)
                except ValidationError as exc:
                    errors.append(exc.detail)
                else:
                    ret.append(validated)
                    errors.append({})

            if any(errors):
                raise ValidationError(errors)

            return ret
        finally:
            delattr(self, '_instance_map')

    def to_representation(self, data):
        # Dealing with nested relationships, data can be a Manager,
        # so, first get a queryset from the Manager if needed.
        # We avoid .all() on QuerySets to preserve Issue #2704 behavior.
        iterable = data.all() if isinstance(data, models.manager.BaseManager) else data

        return [
            self.child.to_representation(item) for item in iterable
        ]